home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / VERSION1.5 / GEMTEXT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-16  |  15.3 KB  |  568 lines
  1. /*************************************************************************
  2.  * GemText.C - Module de gestion des fenetres Textes.                    *
  3.  *************************************************************************/
  4.  
  5. #include "WindGem.h"
  6. #include "winproto.h"
  7. #include <xgemfast.h>
  8. #include <stdio.h>
  9.  
  10. /* Fonctions privées internes à GemText.C */
  11. static void sim_redraw (Wind *wind, int x, int y, int w, int h);
  12. static void WindTextRedraw (Wind *wind);
  13. static void WindTextFulled (Wind *wind);
  14. static void WindTextArrow (Wind *wind);
  15. static void WindTextHSlider (Wind *wind);
  16. static void WindTextVSlider (Wind *wind);
  17. static void WindTextSized (Wind *wind);
  18.  
  19. int WindTextInit (char *file, GRECT *Fpos, char *title)
  20. {
  21.     int fh, nlines = ZERO, i, maxi = ZERO;
  22.     long taille;
  23.     char *zone, *ptr;
  24.     GRECT pos;
  25.     WindText *ptr_txt = (WindText *)malloc(sizeof(WindText));
  26.  
  27.     if (Fpos != NULL)
  28.     {
  29.         pos.g_x = Fpos->g_x;
  30.         pos.g_y = Fpos->g_y;
  31.         pos.g_w = Fpos->g_w;
  32.         pos.g_h = Fpos->g_h;
  33.     }
  34.     else
  35.     {
  36.         pos.g_x = 50;
  37.         pos.g_y = 50;
  38.         pos.g_w = 200;
  39.         pos.g_h = 100;
  40.     }
  41.     if (file)
  42.     {
  43.         taille = exist (file, ZERO);                     /* Prendre la taille du fichier */
  44.         if (taille && ptr_txt)                                 /* S'il existe et memoire dispo */
  45.         {
  46.             zone = (char *)lalloc (taille);            /* Réserver mémoire */
  47.             if (zone)                                                        /* Si mémoire dispo */
  48.             {
  49.                 fh = (int)Fopen (file, FO_READ);    /* Ouvrir fichier */
  50.                 Fread (fh, taille, zone);                    /* Charger en mémoire */
  51.                 Fclose (fh);                                            /* Fermer fichier */
  52.                 ptr = zone;
  53.                 do
  54.                 {
  55.                     if (*ptr == '\r')                                /* Remplacer fins de lignes par '\0' */
  56.                     {
  57.                         *ptr = '\0';
  58.                         nlines++;                                            /* Compter les lignes */
  59.                         ptr++;
  60.                     }
  61.                     ptr++;
  62.                 } while (ptr < zone + taille);
  63.     
  64.                 /* Mémoire pointeurs sur les lignes */
  65.                 ptr_txt->lignes = (char **)malloc (nlines * sizeof (char **));
  66.                 ptr = zone;                                                /* Partir du début */
  67.                 for (i = ZERO ; i < nlines ; i++)    /* Pour chaque ligne */
  68.                 {
  69.                     ptr_txt->lignes[i] = ptr;    /* Pointer dessus */
  70.                     maxi = max (maxi, (int)strlen (ptr));    /* Ligne la plus longue */
  71.                     ptr += (strlen (ptr) + 2);            /* Ligne suivante */
  72.                 }
  73.                 ptr_txt->nbrel = nlines;                        /* Enregistrer nbre de lignes */
  74.                 ptr_txt->nbrec = maxi;                            /* Enregistrer nbre colonnes  */
  75.                 ptr_txt->lin = 0;
  76.                 ptr_txt->col = 0;
  77.             }
  78.             ptr_txt->type = TYP_TEXT_AUTO;
  79.         }
  80.         else
  81.         {
  82.             ptr_txt->lignes = (char **)NULL;
  83.             ptr_txt->nbrel = 0;                                    /* Enregistrer nbre de lignes */
  84.             ptr_txt->nbrec = 0;                                    /* Enregistrer nbre colonnes  */
  85.             ptr_txt->lin = 0;
  86.             ptr_txt->col = 0;
  87.             ptr_txt->type = TYP_TEXT_USER;
  88.         }
  89.     }
  90.     if (title)
  91.         AjouteListe (WTYPTEXT, TW_ATTRIB, Sys->lastTxt, WNORM, title, pos, (void *)ptr_txt);
  92.     else
  93.         AjouteListe (WTYPTEXT, TW_ATTRIB, Sys->lastTxt, WNORM, file, pos, (void *)ptr_txt);
  94.     Sys->lastTxt++;
  95.     return (Sys->lastTxt - 1);
  96. }
  97.  
  98. int GetWindText (int numTxt, char **ligne[], int *nbcol)
  99. {
  100.     Wind *wind;
  101.     int nblig = 0;
  102.     WindText *ptr_txt;
  103.     
  104.     wind = ObjListe(numTxt);
  105.     if (wind != WIND_NULL && wind->type == WTYPTEXT)
  106.     {
  107.         ptr_txt = wind->cont.text;
  108.         *ligne = ptr_txt->lignes;
  109.         nblig = ptr_txt->nbrel;
  110.         *nbcol = ptr_txt->nbrec;
  111.     }
  112.  
  113.     return nblig;
  114. }
  115.  
  116. void SetWindText (int numTxt, int nblig, int nbcol, char **ligne)
  117. {
  118.     Wind *wind;
  119.     WindText *ptr_txt;
  120.     
  121.     wind = ObjListe(numTxt);
  122.     if (wind != WIND_NULL && wind->type == WTYPTEXT)
  123.     {
  124.         ptr_txt = wind->cont.text;
  125.         ptr_txt->lignes = ligne;
  126.         ptr_txt->nbrel = nblig;
  127.         ptr_txt->nbrec = nbcol;
  128.         sim_redraw (wind, wind->Xpos, wind->Ypos, wind->Wpos, wind->Hpos);
  129.     }
  130. }
  131.  
  132. void WindTextDo(Wind *wind, int evnt)
  133. {
  134.     GRECT coord;
  135.     WindText *ptr_txt = wind->cont.text;
  136.     int xw, yw, ww, hw, hauteur_page;
  137.  
  138.     GetWorkXYWH (wind->numObj, &coord);
  139.     xw = coord.g_x;
  140.     yw = coord.g_y;
  141.     ww = coord.g_w;
  142.     hw = coord.g_h;    
  143.     if ((evnt > 0) && (evnt & MU_MESAG))                     /* SI EVENEMENT DE MESSAGE */
  144.     {
  145.         switch(buff[0])
  146.         {
  147.         case WM_REDRAW :
  148.             WindTextRedraw (wind);
  149.             break;
  150.         
  151.         case WM_TOPPED :
  152.             wind_set (wind->handle, WF_TOP);        /* Mettre la fenêtre au 1° plan */
  153.             break;
  154.         
  155.         case WM_CLOSED :
  156.             WindDelete(wind->numObj);
  157.             break;
  158.             
  159.         case WM_FULLED :
  160.             WindTextFulled (wind);
  161.             break;
  162.  
  163.         case WM_ARROWED :
  164.             WindTextArrow (wind);
  165.          break;
  166.         
  167.         case WM_HSLID :
  168.             WindTextHSlider (wind);
  169.             break;
  170.             
  171.         case WM_VSLID :
  172.             WindTextVSlider (wind);
  173.             break;
  174.             
  175.         case WM_SIZED :
  176.             WindTextSized (wind);
  177.             break;
  178.             
  179.         case WM_MOVED :
  180.             /* Nouvelles coordonnées : */
  181.             wind_set (wind->handle, WF_CURRXYWH, buff[4], buff[5], buff[6], buff[7]);
  182.             if (wind->iconified == FALSE)
  183.             {
  184.                 wind->Xpos = buff[4];
  185.                 wind->Ypos = buff[5];
  186.                 ptr_txt->full = 0;                    /* Annuler le flag de pleine ouverture */
  187.  
  188.                 RecaleWind (wind);
  189.             }
  190.             break;
  191.  
  192.         case WM_ICONIFY :
  193.             graf_shrinkbox(buff[4], buff[5], buff[6], buff[7], wind->Xpos, wind->Ypos, wind->Wpos, wind->Hpos);
  194.             wind_set(buff[3], WF_ICONIFY, buff[4], buff[5], buff[6], buff[7]);
  195.             wind->iconified = TRUE;
  196.             break;
  197.                 
  198.         case WM_UNICONIFY :
  199.             graf_growbox( wind->Xpos, wind->Ypos, wind->Wpos, wind->Hpos, buff[4], buff[5], buff[6], buff[7]);
  200.             wind_set(buff[3], WF_UNICONIFY, buff[4], buff[5], buff[6], buff[7]);
  201.             wind->iconified = FALSE;
  202.             break;
  203.         }
  204.     }
  205.     else if (evnt > 0)
  206.         return;
  207.  
  208.     switch (evnt)
  209.     {
  210.         case EV_HELP :    /* Help */
  211.             form_alert(1,"[1][(shft) / : (pg)-lig haut/bas|(shft) / : (pg)-lig droite/gauche|(shft) Home : (fin)-début de texte|Esc : fermeture][Ok]");
  212.             break;
  213.             
  214.         case EV_ESC :        /* Escape */
  215.             EnvoiMessage(WM_CLOSED, wind->handle, ZERO);
  216.             break;
  217.  
  218.         case EV_ARLF :    /* gauche */
  219.             buff[4] = WA_LFLINE;
  220.             WindTextArrow(wind);
  221.             break;
  222.  
  223.         case EV_ARRT :    /* droite */
  224.             buff[4] = WA_RTLINE;
  225.             WindTextArrow(wind);
  226.             break;
  227.  
  228.         case EV_ARUP :    /* Haute  */
  229.             buff[4] = WA_UPLINE;
  230.             WindTextArrow (wind);
  231.             break;
  232.  
  233.         case EV_ARDN :    /* Basse  */
  234.             buff[4] = WA_DNLINE;
  235.             WindTextArrow (wind);
  236.             break;
  237.  
  238.         case EV_SHARLF :    /*  gauche */
  239.             buff[4] = WA_LFPAGE;
  240.             WindTextArrow(wind);
  241.             break;
  242.  
  243.         case EV_SHARRT :    /*  droite */
  244.             buff[4] = WA_RTPAGE;
  245.             WindTextArrow(wind);
  246.             break;
  247.  
  248.         case EV_SHARUP :    /*  Haute  */
  249.             buff[4] = WA_UPPAGE;
  250.             WindTextArrow(wind);
  251.             break;
  252.  
  253.         case EV_SHARDN :    /*  Basse  */
  254.             buff[4] = WA_DNPAGE;
  255.             WindTextArrow(wind);
  256.             break;
  257.  
  258.         case EV_HOME :    /* HOME */
  259.             if (ptr_txt->lin > 0)
  260.             {
  261.                 ptr_txt->lin = 0;
  262.                 sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  263.                 WindTextSliders (wind);                 /* Actualiser les sliders */
  264.             }
  265.             break;
  266.             
  267.         case EV_SHHOME :    /*  HOME */
  268.             if (ptr_txt->lin < ptr_txt->nbrel - (hw / Sys->Hchar))
  269.             {
  270.                 ptr_txt->lin = ptr_txt->nbrel - (hw / Sys->Hchar);
  271.                 sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  272.                 WindTextSliders (wind);                 /* Actualiser les sliders */
  273.             }
  274.             break;
  275.     }
  276. }
  277.  
  278. static void sim_redraw (Wind *wind, int x, int y, int w, int h)
  279. {
  280.     buff[3] = wind->handle;
  281.     buff[4] = x;
  282.     buff[5] = y;
  283.     buff[6] = w;
  284.     buff[7] = h;
  285.     WindTextRedraw (wind);
  286. }
  287.  
  288. static void WindTextRedraw (Wind *wind)
  289. {    /* Gestion des redraws */
  290.     GRECT r, rd, coord;
  291.     int i, y_base, nbre;
  292.     int xo, yo, wo, ho, xy[4];
  293.     WindText *ptr_txt = wind->cont.text;
  294.     char chaine[256];
  295.     
  296.     rd.g_x = buff[4];    /* Coordonnées rectangle à redessiner */
  297.     rd.g_y = buff[5];
  298.     rd.g_w = buff[6];
  299.     rd.g_h = buff[7];
  300.  
  301.     if (wind->iconified == TRUE)
  302.     {
  303.         DrawIcone (wind->handle, &rd);
  304.     }
  305.     else
  306.     {
  307.         GetWorkXYWH (wind->numObj, &coord);
  308.  
  309.         xo = coord.g_x;
  310.         yo = coord.g_y;
  311.         wo = coord.g_w;
  312.         ho = coord.g_h;
  313.  
  314.         nbre = ho / Sys->Hchar;
  315.  
  316.         v_hide_c (Sys->VdiHandle);    /* Virer la souris */
  317.         wind_update (BEG_UPDATE);     /* Bloquer les fonctions de la souris */
  318.  
  319.         /* Demande les coord. et dimensions du 1° rectangle de la liste */
  320.         wind_get (wind->handle, WF_FIRSTXYWH, &r.g_x, &r.g_y, &r.g_w, &r.g_h);
  321.  
  322.         while (r.g_w && r.g_h)            /* Tant qu'il y a largeur ou hauteur... */
  323.         {
  324.             set_clip (1, &r);     /* Clipping ON */
  325.             if (rc_intersect (&rd, &r)) /* Si intersection des 2 zones */
  326.             {
  327.                 if (wind->adr_wmenu != (OBJECT *)NULL)
  328.                 { /* On commence par afficher la barre de menu */
  329.             objc_draw (wind->adr_wmenu, BARMENU, MAX_DEPTH, r.g_x, r.g_y, r.g_w, r.g_h);
  330.               }
  331.                 if (wind->adr_wtoolbar != (OBJECT *)NULL)
  332.                 { /* On affiche la ToolBar */
  333.             objc_draw (wind->adr_wtoolbar, ROOT, MAX_DEPTH, r.g_x, r.g_y, r.g_w, r.g_h);
  334.               }
  335.                 /* -- */
  336.                 y_base = yo + Sys->baseline;
  337.  
  338.         xy[0] = xo;                        /* Préparer effacement fenêtre */
  339.         xy[1] = yo;
  340.         xy[2] = xo + wo - 1;
  341.         xy[3] = yo + ho - 1;
  342.  
  343.         vsf_color(Sys->VdiHandle, WHITE);
  344.                 vr_recfl(Sys->VdiHandle, xy);
  345.                 vswr_mode(Sys->VdiHandle, MD_TRANS);
  346.                 i = ptr_txt->lin;
  347.                 while (i < min(nbre+ptr_txt->lin+1,ptr_txt->nbrel))
  348.                 {
  349.                     strcopy(chaine, ptr_txt->lignes[i], ptr_txt->col, strlen(ptr_txt->lignes[i]));
  350.                     v_gtext(Sys->VdiHandle, xo + 1, y_base, chaine);
  351.                     y_base += Sys->Hchar;
  352.                     i++;
  353.                 }
  354.                 vswr_mode(Sys->VdiHandle, MD_REPLACE);
  355.                 /* -- */
  356.             }
  357.             /* Rectangle suivant */
  358.             set_clip (0, &r);     /* Clipping OFF */
  359.             wind_get (wind->handle, WF_NEXTXYWH, &r.g_x, &r.g_y, &r.g_w, &r.g_h);
  360.         }
  361.         wind_update (END_UPDATE);     /* Débloquer les fonctions de la souris */
  362.         v_show_c (Sys->VdiHandle, 1);             /* Rappeler la souris */
  363.     }
  364. }
  365.  
  366. static void WindTextFulled (Wind *wind)
  367. {
  368.     int x, y, w, h;
  369.     WindText *ptr_txt = wind->cont.text;
  370.  
  371.     if (ptr_txt->full)
  372.     {
  373.         wind_get (wind->handle, WF_PREVXYWH, &x, &y, &w, &h);      /* Coord. précéd. */
  374.         wind_set (wind->handle, WF_CURRXYWH, x, y, w, h);          /* Nouvelles coord. */
  375.         ptr_txt->full = FALSE;
  376.     }
  377.     else
  378.     {
  379.         wind_set (wind->handle, WF_CURRXYWH, Sys->Xdesk, Sys->Ydesk, Sys->Wdesk, Sys->Hdesk);
  380.         ptr_txt->full = TRUE;
  381.     }
  382.     wind_get (wind->handle, WF_CURRXYWH, &wind->Xpos, &wind->Ypos, &wind->Wpos, &wind->Hpos);
  383.     WindTextSliders (wind);
  384.  
  385.     RecaleWind(wind);
  386. }
  387.  
  388. static void WindTextArrow (Wind *wind)
  389. {
  390.     GRECT coord;
  391.     int xw, yw, ww, hw, decal, pxy[8], hauteur_page, largeur_page;
  392.     WindText *ptr_txt = wind->cont.text;
  393.  
  394.     GetWorkXYWH (wind->numObj, &coord);
  395.     xw = coord.g_x;
  396.     yw = coord.g_y;
  397.     ww = coord.g_w;
  398.     hw = coord.g_h;
  399.     hauteur_page = hw / Sys->Hchar;
  400.     largeur_page = ww / Sys->Wchar;
  401.     switch (buff[4])
  402.     {
  403.     case WA_UPPAGE :                /* Page vers le haut */
  404.         if (ptr_txt->lin > 0)
  405.         {
  406.             ptr_txt->lin = max (ptr_txt->lin - hauteur_page, 0);
  407.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  408.             WindTextSliders (wind);                 /* Actualiser les sliders */
  409.         }
  410.         break;
  411.     case WA_DNPAGE :                /* Page vers le bas */
  412.         if ((ptr_txt->lin + hauteur_page) < ptr_txt->nbrel)
  413.         {
  414.             ptr_txt->lin = min (ptr_txt->lin + hauteur_page, ptr_txt->nbrel - hauteur_page);
  415.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  416.             WindTextSliders (wind);                 /* Actualiser les sliders */
  417.         }
  418.         break;
  419.     case WA_UPLINE :                /* Ligne vers le haut */
  420.         if (ptr_txt->lin > 0)
  421.         {
  422.             ptr_txt->lin--;
  423.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  424.             WindTextSliders (wind);                 /* Actualiser les sliders */
  425.         }
  426.         break;
  427.     case WA_DNLINE :                /* Ligne vers le bas */
  428.         if ((ptr_txt->lin + hauteur_page) < ptr_txt->nbrel)
  429.         {
  430.             ptr_txt->lin++;
  431.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  432.             WindTextSliders (wind);                 /* Actualiser les sliders */
  433.         }
  434.         break;
  435.     case WA_LFPAGE :                /* Page vers la gauche */
  436.     if (ptr_txt->col > 0)
  437.         {
  438.             ptr_txt->col = max (ptr_txt->col - largeur_page, 0);
  439.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  440.             WindTextSliders (wind);                 /* Actualiser les sliders */
  441.         }
  442.         break;
  443.         
  444.     case WA_RTPAGE :                /* Page vers la droite */
  445.          if ((ptr_txt->col + largeur_page) < ptr_txt->nbrec)
  446.         {
  447.             ptr_txt->col = min (ptr_txt->col + largeur_page, ptr_txt->nbrec - largeur_page);
  448.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  449.             WindTextSliders (wind);                 /* Actualiser les sliders */
  450.         }
  451.         break;
  452.         
  453.     case WA_LFLINE :                /* Ligne vers la gauche */
  454.         if (ptr_txt->col > 0)
  455.         {
  456.             ptr_txt->col--;
  457.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  458.             WindTextSliders (wind);                 /* Actualiser les sliders */
  459.         }
  460.         break;
  461.         
  462.     case WA_RTLINE :                /* Ligne vers la droite */
  463.         if ((ptr_txt->col + largeur_page) < ptr_txt->nbrec)
  464.         {
  465.             ptr_txt->col++;
  466.             sim_redraw (wind, xw, yw, ww, hw);    /* Réaffichage */
  467.             WindTextSliders (wind);                 /* Actualiser les sliders */
  468.         }
  469.         break;
  470.     }
  471. }
  472.  
  473. static void WindTextSized (Wind *wind)
  474. {
  475.     WindText *ptr_txt = wind->cont.text;
  476.     int x, y, w, h;
  477.     
  478.     wind_set(wind->handle, WF_CURRXYWH, buff[4], buff[5], buff[6], buff[7]);
  479.     ptr_txt->full = 0;                            /* Annuler le flag de pleine ouverture */
  480.     WindTextSliders (wind);                             /* Tailles et positions sliders */
  481.     /* Enregistrer les coordonnées */
  482.     wind_get(wind->handle, WF_CURRXYWH, &wind->Xpos, &wind->Ypos, &wind->Wpos, &wind->Hpos);
  483.  
  484.     wind_get(wind->handle, WF_WORKXYWH, &x, &y, &w, &h);
  485.     if (wind->adr_wtoolbar != (OBJECT *)NULL)
  486.         wind->adr_wtoolbar->ob_width = w;
  487.  
  488.     /* Sans cette ligne, le réaffichage n'est pas correcte... */
  489. /*    sim_redraw(wind, wind->Xpos, wind->Ypos, wind->Wpos, wind->Hpos);*/
  490. }
  491.  
  492. static void WindTextHSlider (Wind *wind)
  493. {
  494.     GRECT coord;
  495.     int slide, xw, yw, ww, hw, largeur_page;
  496.     WindText *ptr_txt = wind->cont.text;
  497.  
  498.     GetWorkXYWH (wind->numObj, &coord);
  499.     xw = coord.g_x;
  500.     yw = coord.g_y;
  501.     ww = coord.g_w;
  502.     hw = coord.g_h;
  503.  
  504.     slide = buff[4];
  505.     largeur_page = ww / Sys->Wchar;                    /* Hauteur en lignes de texte */
  506.     ptr_txt->col = (int)((long)slide * (ptr_txt->nbrec - largeur_page) / 1000);
  507.     wind_set(wind->handle, WF_HSLIDE, slide);
  508.     sim_redraw(wind, xw, yw, ww, hw);
  509. }
  510.  
  511. static void WindTextVSlider (    Wind *wind)
  512. {
  513.     GRECT coord;
  514.     int slide, xw, yw, ww, hw, hauteur_page;
  515.     WindText *ptr_txt = wind->cont.text;
  516.  
  517.     GetWorkXYWH (wind->numObj, &coord);
  518.     xw = coord.g_x;
  519.     yw = coord.g_y;
  520.     ww = coord.g_w;
  521.     hw = coord.g_h;
  522.  
  523.     slide = buff[4];
  524.     hauteur_page = hw / Sys->Hchar;                    /* Hauteur en lignes de texte */
  525.     ptr_txt->lin = (int)((long)slide * (ptr_txt->nbrel - hauteur_page) / 1000);
  526.     wind_set(wind->handle, WF_VSLIDE, slide);
  527.     sim_redraw(wind, xw, yw, ww, hw);
  528. }
  529.  
  530. void WindTextSliders (Wind *wind)
  531. {
  532.     GRECT coord;
  533.     int xw, yw, ww, hw, hauteur_page, largeur_page;
  534.     WindText *ptr_txt = wind->cont.text;
  535.     
  536.     GetWorkXYWH (wind->numObj, &coord);
  537.     xw = coord.g_x;
  538.     yw = coord.g_y;
  539.     ww = coord.g_w;
  540.     hw = coord.g_h;
  541.  
  542.     hauteur_page = hw / Sys->Hchar;
  543.     largeur_page = ww / Sys->Wchar;
  544.     
  545.     /* Taille slider vertical */
  546.     wind_set(wind->handle, WF_VSLSIZE, (int)((1000L * hauteur_page) / ptr_txt->nbrel));
  547.     ptr_txt->lin = min(ptr_txt->lin, ptr_txt->nbrel - hauteur_page);
  548.     if (ptr_txt->lin < 0)
  549.         ptr_txt->lin = 0;
  550.  
  551.     /* Taille slider horizontal */
  552.     wind_set(wind->handle, WF_HSLSIZE, (int)((1000L * largeur_page) / ptr_txt->nbrec));
  553.     ptr_txt->col = min(ptr_txt->col, ptr_txt->nbrec - largeur_page);
  554.     if (ptr_txt->col < 0)
  555.         ptr_txt->col = 0;
  556.  
  557.     /* Position slider vertical */
  558.     wind_set(wind->handle, WF_VSLIDE, (int)((1000L * ptr_txt->lin)
  559.             / (ptr_txt->nbrel - hauteur_page)));
  560.             
  561.     /* Position slider horizontal */
  562.     wind_set(wind->handle, WF_HSLIDE, (int)((1000L * ptr_txt->col)
  563.             / (ptr_txt->nbrec - largeur_page)));
  564.             
  565. }
  566.  
  567. /**************************-=< Fin du module >=-**************************/
  568.